
package com.bskms.controller;

import java.util.Date;
import java.util.List;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import com.bskms.bean.ClaTea;
import com.bskms.bean.Classes;
import com.bskms.bean.Food;
import com.bskms.bean.Material;
import com.bskms.bean.Page;
import com.bskms.bean.Pay;
import com.bskms.bean.Role;
import com.bskms.bean.User;
import com.bskms.model.LayuiMap;
import com.bskms.model.ResultMap;
import com.bskms.model.UserParameter;
import com.bskms.service.ClassService;
import com.bskms.service.FoodService;
import com.bskms.service.IExcel2DB;
import com.bskms.service.MaterialService;
import com.bskms.service.PageRoleService;
import com.bskms.service.PageService;
import com.bskms.service.PayService;
import com.bskms.service.RoleService;
import com.bskms.service.TeaService;
import com.bskms.service.UserRoleService;
import com.bskms.service.UserService;
import com.bskms.utils.MD5;

@Controller
@RequestMapping(value = "/sa")
public class SaController {

	@Autowired
	private PageService pageService;
	@Autowired
	private RoleService roleService;
	@Autowired
	private PageRoleService pageRoleService;
	@Autowired
	private UserRoleService userRoleService;
	@Autowired
	private UserService userService;
	@Autowired
	private IExcel2DB excel2db;
	@Autowired
	private ClassService classService;
	@Autowired
	private TeaService teaService;
	@Autowired
	private PayService payService;
	@Autowired
	private MaterialService materialService;
	@Autowired
	private FoodService foodService;

	private final Logger logger = LoggerFactory.getLogger(SaController.class);
	/**
	 * 跳转到页面管理设置页面
	 * 
	 * 功能说明：
	 * - 显示系统中所有可管理的页面列表
	 * - 提供页面的增删改查功能
	 * - 用于系统权限管理和页面配置
	 * 
	 * 实现逻辑：
	 * 1. 调用pageService.getAllPage()获取所有页面信息
	 * 2. 将页面列表存储到Model中传递给前端
	 * 3. 返回页面管理视图，前端通过AJAX调用相关接口进行数据操作
	 * 
	 * @param model Spring MVC的Model对象，用于向前端传递数据
	 * @return String 返回页面管理视图名称 "sa/page"
	 */
	@RequestMapping("/page")
	public String page(Model model) {
		// 获取系统中所有页面信息
		List<Page> pageList = pageService.getAllPage();
		// 将页面列表存储到Model中，便于前端页面获取和展示
		model.addAttribute("pageList", pageList);
		return "sa/page";
	}

	/**
	 * 跳转到角色管理设置页面
	 * 
	 * 功能说明：
	 * - 显示系统中所有角色的管理界面
	 * - 提供角色的增删改查功能
	 * - 用于系统权限管理和角色配置
	 * 
	 * 实现逻辑：
	 * 1. 直接返回角色管理视图
	 * 2. 前端页面会通过AJAX调用getAllRole等接口获取数据
	 * 3. 支持角色的动态管理和权限分配
	 * 
	 * @param model Spring MVC的Model对象（当前未使用）
	 * @return String 返回角色管理视图名称 "sa/role"
	 */
	@RequestMapping("/role")
	public String role(Model model) {
		return "sa/role";
	}

	/**
	 * 获取所有角色信息
	 * 
	 * 功能说明：
	 * - 返回系统中所有可管理的角色列表
	 * - 用于角色管理界面的数据展示
	 * - 支持前端动态加载角色数据
	 * 
	 * 实现逻辑：
	 * 1. 直接调用roleService.getAllRole()方法
	 * 2. 该方法会查询数据库中所有角色信息
	 * 3. 返回完整的角色信息列表
	 * 
	 * @return List<Role> 所有角色信息的列表
	 */
	@RequestMapping("/getAllRole")
	@ResponseBody
	public List<Role> getAllRole() {
		return roleService.getAllRole();
	}

	/**
	 * 获取所有页面信息
	 * 
	 * 功能说明：
	 * - 返回系统中所有可管理的页面列表
	 * - 用于页面管理界面的数据展示
	 * - 支持前端动态加载页面数据
	 * 
	 * 实现逻辑：
	 * 1. 直接调用pageService.getAllPage()方法
	 * 2. 该方法会查询数据库中所有未删除的页面
	 * 3. 返回完整的页面信息列表
	 * 
	 * @return List<Page> 所有页面信息的列表
	 */
	@RequestMapping("/getAllPage")
	@ResponseBody
	public List<Page> getAllPage() {
		return pageService.getAllPage();
	}

	/**
	 * 根据角色ID获取页面列表
	 * 
	 * 功能说明：
	 * - 查询指定角色拥有的页面权限
	 * - 用于角色权限配置和页面分配
	 * - 支持角色权限的动态管理
	 * 
	 * 实现逻辑：
	 * 1. 接收角色ID参数
	 * 2. 调用pageService.getAllPageByRoleId()方法
	 * 3. 查询该角色关联的所有页面
	 * 4. 返回页面列表供前端展示
	 * 
	 * @param roleId 角色ID
	 * @return Object 该角色拥有的页面列表
	 */
	@RequestMapping("/getPageByRole")
	@ResponseBody
	public Object getPageByRole(Integer roleId) {
		return pageService.getAllPageByRoleId(roleId);
	}

	/**
	 * 根据页面ID更新页面信息
	 * 
	 * 功能说明：
	 * - 更新指定页面的基本信息
	 * - 支持修改页面名称、URL、描述等属性
	 * - 用于页面配置的动态调整
	 * 
	 * 实现逻辑：
	 * 1. 接收包含更新信息的Page对象
	 * 2. 调用pageService.updatePageById()方法
	 * 3. 该方法内部会进行数据验证和更新操作
	 * 4. 返回操作结果（成功/失败）
	 * 
	 * @param page 包含更新信息的页面对象
	 * @return ResultMap 包含操作结果的响应对象
	 */
	@RequestMapping("/updatePageById")
	@ResponseBody
	public ResultMap updatePageById(Page page) {
		return pageService.updatePageById(page);
	}

	/**
	 * 添加新页面
	 * 
	 * 功能说明：
	 * - 创建新的系统页面
	 * - 支持设置页面层级结构和权限
	 * - 用于系统功能的扩展和配置
	 * 
	 * 实现逻辑：
	 * 1. 接收包含页面信息的Page对象
	 * 2. 调用pageService.addPage()方法
	 * 3. 该方法会进行数据验证并保存到数据库
	 * 4. 返回添加后的页面对象（包含生成的ID）
	 * 
	 * @param page 包含页面信息的对象
	 * @return Page 添加成功后的页面对象（包含生成的ID）
	 */
	@RequestMapping("/addPage")
	@ResponseBody
	public Page addPage(Page page) {
		return pageService.addPage(page);
	}

	/**
	 * 根据页面ID删除页面
	 * 
	 * 功能说明：
	 * - 删除指定的系统页面
	 * - 采用软删除方式，设置删除标志位
	 * - 确保数据完整性和可恢复性
	 * 
	 * 实现逻辑：
	 * 1. 验证页面ID参数的有效性
	 * 2. 如果参数无效，返回错误信息
	 * 3. 调用pageService.delPageById()方法
	 * 4. 该方法会设置页面的删除标志位而不是物理删除
	 * 5. 返回删除操作的结果
	 * 
	 * @param id 要删除的页面ID
	 * @return ResultMap 包含删除结果的响应对象
	 */
	@RequestMapping("/delPageById")
	@ResponseBody
	public ResultMap delPageById(Integer id) {
		// 参数验证：检查页面ID是否有效
		if (null == id) {
			return new ResultMap().fail().message("参数错误");
		}
		return pageService.delPageById(id);
	}

	/**
	 * 添加新角色
	 * 
	 * 功能说明：
	 * - 创建新的系统角色
	 * - 支持自定义角色名称
	 * - 用于系统权限的扩展和配置
	 * 
	 * 实现逻辑：
	 * 1. 接收角色名称参数
	 * 2. 调用roleService.addRole()方法
	 * 3. 该方法会进行数据验证并保存到数据库
	 * 4. 返回添加操作的结果（SUCCESS/ERROR）
	 * 
	 * @param name 角色名称
	 * @return String 操作结果："SUCCESS"表示成功，"ERROR"表示失败
	 */
	@RequestMapping("/addRole")
	@ResponseBody
	public String addRole(String name) {
		return roleService.addRole(name);
	}

	/**
	 * 根据角色ID删除角色
	 * 
	 * 功能说明：
	 * - 删除指定的系统角色
	 * - 级联删除相关的权限和用户关联
	 * - 确保数据一致性和完整性
	 * 
	 * 实现逻辑：
	 * 1. 删除角色基本信息（roleService.delRoleById）
	 * 2. 删除角色页面权限关联（pageRoleService.delPageRoleByRoleId）
	 * 3. 删除用户角色关联（userRoleService.delUserRoleByRoleId）
	 * 4. 只有所有操作都成功才返回SUCCESS
	 * 5. 任何一个操作失败都返回ERROR
	 * 
	 * @param id 要删除的角色ID
	 * @return String 操作结果："SUCCESS"表示成功，"ERROR"表示失败
	 */
	@RequestMapping("/delRole")
	@ResponseBody
	public String delRole(int id) {
		// 第一步：删除角色基本信息
		boolean flag1 = roleService.delRoleById(id);
		// 第二步：删除角色页面权限关联表
		boolean flag2 = pageRoleService.delPageRoleByRoleId(id);
		// 第三步：删除该角色的所有用户关联
		boolean flag3 = userRoleService.delUserRoleByRoleId(id);

		// 只有所有操作都成功才返回成功
		if (flag1 && flag2 && flag3) {
			return "SUCCESS";
		}
		return "ERROR";
	}

	/**
	 * 根据角色ID修改角色信息
	 * 
	 * 功能说明：
	 * - 更新指定角色的基本信息
	 * - 支持修改角色名称和描述
	 * - 用于角色配置的动态调整
	 * 
	 * 实现逻辑：
	 * 1. 接收角色ID和新的角色名称
	 * 2. 调用roleService.updateRoleById()方法
	 * 3. 该方法会更新数据库中的角色信息
	 * 4. 根据更新结果返回操作状态
	 * 
	 * @param id 角色ID
	 * @param name 新的角色名称
	 * @return String 操作结果："SUCCESS"表示成功，"ERROR"表示失败
	 */
	@RequestMapping("/updateRole")
	@ResponseBody
	public String updateRole(Integer id, String name) {
		int n = roleService.updateRoleById(id, name);
		if (n != 0) {
			return "SUCCESS";
		}
		return "ERROR";
	}

	/**
	 * Method name: addPageRoleByRoleId <BR>
	 * Description: 增加某个角色的权限页面 <BR>
	 * 
	 * @param roleId
	 * @param pageIds
	 * @return String<BR>
	 */
	@RequestMapping("/addPageRoleByRoleId")
	@ResponseBody
	public String addPageRoleByRoleId(Integer roleId, Integer[] pageIds) {

		if (null == roleId) {
			return "ERROR";
		}

		// 先删除老的权限
		boolean flag1 = pageRoleService.delPageRoleByRoleId(roleId);
		boolean flag2 = pageRoleService.addPageRoles(roleId, pageIds);

		if (flag1 && flag2) {
			return "SUCCESS";
		}
		return "ERROR";
	}

	/**
	 * Method name: getAllUserByMap <BR>
	 * Description: 根据角色查询下面所有的人员/非角色下所有人员 <BR>
	 * 
	 * @param roleId
	 * @param roleNot
	 * @param page
	 * @param limit
	 * @return Object<BR>
	 */
	@RequestMapping("/getAllUserByRoleId")
	@ResponseBody
	public Object getAllUserByRoleId(Integer roleId, String roleNot, Integer page, Integer limit) {
		if (null == roleNot) {
			return userService.getAllUserByRoleId(roleId, page, limit);
		}
		return userService.getAllUserByNotRoleId(roleId, page, limit);
	}

	/**
	 * Method name: delUserRoleByUserIdAndRoleId <BR>
	 * Description: 根据用户id权限id删除用户权限表 <BR>
	 * 
	 * @param userId
	 * @param roleId
	 * @return ResultMap<BR>
	 */
	@RequestMapping("/delUserRoleByUserIdAndRoleId")
	@ResponseBody
	public ResultMap delUserRoleByUserIdAndRoleId(String userId, Integer roleId) {
		return userRoleService.delUserRoleByUserIdAndRoleId(userId, roleId);
	}

	/**
	 * Method name: selectUserRole <BR>
	 * Description: 跳转到选择用户角色页面 <BR>
	 * 
	 * @return String<BR>
	 */
	@RequestMapping("/selectUserRole")
	public String selectUserRole() {
		return "sa/selectUserRole";
	}

	/**
	 * Method name: addUserRole <BR>
	 * Description: 增加用户的角色 <BR>
	 * 
	 * @param roleId
	 * @param userIds
	 * @return String<BR>
	 */
	@RequestMapping("/addUserRole")
	@ResponseBody
	public String addUserRole(Integer roleId, String[] userIds) {
		return userRoleService.addUserRole(roleId, userIds);
	}

	/**
	 * Method name: userAddPage <BR>
	 * Description: 用户添加页面 <BR>
	 * 
	 * @return String<BR>
	 */
	@RequestMapping(value = "/userAddPage")
	public String userAddPage() {
		return "sa/userAdd";
	}

	/**
	 * Method name: userPage <BR>
	 * Description: 用户管理页面 <BR>
	 * 
	 * @return String<BR>
	 */
	@RequestMapping(value = "/userPage")
	public String userPage() {
		return "sa/userList";
	}

	/**
	 * Method name: getAllUserByLimit <BR>
	 * Description: 根据条件获取所有用户 <BR>
	 * 
	 * @param userParameter
	 * @return Object<BR>
	 */
	@RequestMapping("/getAllUserByLimit")
	@ResponseBody
	public Object getAllUserByLimit(UserParameter userParameter) {
		return userService.getAllUserByLimit(userParameter);
	}

	/**
	 * Method name: getAllDelUserByLimit <BR>
	 * Description: 获取所有删除用户 <BR>
	 * 
	 * @param userParameter
	 * @return Object<BR>
	 */
	@RequestMapping("/getAllDelUserByLimit")
	@ResponseBody
	public Object getAllDelUserByLimit(UserParameter userParameter) {
		return userService.getAllDelUserByLimit(userParameter);
	}

	/**
	 * Method name: delUser <BR>
	 * Description: 批量删除用户 <BR>
	 * 
	 * @param ids
	 * @return String<BR>
	 */
	@RequestMapping(value = "delUser")
	@ResponseBody
	@Transactional
	public String delUser(String[] ids) {
		Subject subject = SecurityUtils.getSubject();
		User user = (User) subject.getPrincipal();
		try {
			for (String id : ids) {
				if (id.equals(user.getUserId())) {
					return "DontOP";
				}
				userService.delUserById(id);
			}
			return "SUCCESS";
		} catch (Exception e) {
			logger.error("根据用户id更新用户异常", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return "ERROR";
		}
	}

	/**
	 * Method name: addUserPage <BR>
	 * Description: 增加用户界面 <BR>
	 * 
	 * @return String<BR>
	 */
	@RequestMapping(value = "/addUserPage")
	public String addUserPage(String userId, Model model) {
		model.addAttribute("manageUser", userId);
		if (null != userId) {
			User user = userService.selectByPrimaryKey(userId);
			model.addAttribute("manageUser", user);
		}
		return "sa/userAdd";
	}

	/**
	 * Method name: importUser <BR>
	 * Description: 导入用户页面 <BR>
	 * 
	 * @return String<BR>
	 */
	@RequestMapping(value = "/importUser")
	public String importUser() {
		return "sa/importUser";
	}

	/**
	 * Method name: uploadAjax <BR>
	 * Description: 导入用户操作 <BR>
	 * 
	 * @param file
	 * @return Object<BR>
	 */
	@ResponseBody
	@RequestMapping("/uploadAjaxByUser")
	public Object uploadAjaxByUser(@RequestParam("file") MultipartFile file) {
		String msg = excel2db.importUserExcel2DB(file);
		LayuiMap layui = new LayuiMap();
		if (msg.equals("Y")) {// 导入成功
			return layui.success().message("success");
		}
		// 导入失败
		return layui.fail().message(msg);
	}

	/**
	 * 检测用户账号是否存在
	 * 
	 * 功能说明：
	 * - 在添加用户前检查用户ID是否已存在
	 * - 防止重复创建相同ID的用户
	 * - 用于前端表单验证
	 * 
	 * 实现逻辑：
	 * 1. 接收前端传递的用户ID
	 * 2. 调用userService查询该ID对应的用户信息
	 * 3. 如果用户存在，返回用户对象；如果不存在，返回null
	 * 4. 前端根据返回结果判断是否允许创建该用户
	 * 
	 * @param userId 要检查的用户ID
	 * @return User 如果用户存在返回用户对象，否则返回null
	 */
	@ResponseBody
	@RequestMapping("/checkUserId")
	public User checkUserId(String userId) {
		return userService.selectByPrimaryKey(userId);
	}

	/**
	 * 添加新用户
	 * 
	 * 功能说明：
	 * - 创建新的用户账号
	 * - 自动对密码进行MD5加密
	 * - 设置账号创建时间
	 * - 支持批量用户创建
	 * 
	 * 实现逻辑：
	 * 1. 接收前端传递的用户信息
	 * 2. 对用户密码进行MD5加密处理
	 * 3. 设置账号创建时间为当前时间
	 * 4. 调用userService.addUser()方法保存到数据库
	 * 5. 返回操作结果（SUCCESS/ERR）
	 * 
	 * @param user 包含用户信息的User对象
	 * @return String 操作结果："SUCCESS"表示成功，"ERR"表示失败
	 */
	@ResponseBody
	@RequestMapping("/addUser")
	public String addUser(User user) {
		try {
			// 对用户密码进行MD5加密，确保密码安全
			user.setUserPassword(MD5.md5(user.getUserPassword()));
			// 设置账号创建时间为当前时间
			user.setAccountCreateTime(new Date());
			// 调用服务层方法保存用户信息
			userService.addUser(user);
			return "SUCCESS";
		} catch (Exception e) {
			// 记录异常日志并返回错误信息
			logger.error("添加用户异常", e);
			return "ERR";
		}
	}

	/**
	 * 更新用户信息
	 * 
	 * 功能说明：
	 * - 更新现有用户的基本信息
	 * - 支持修改用户ID（需要更新相关关联表）
	 * - 支持密码修改（会自动加密）
	 * - 保持账号创建时间不变
	 * 
	 * 实现逻辑：
	 * 1. 接收用户信息和新旧用户ID
	 * 2. 调用userService.updateUser()方法进行更新
	 * 3. 该方法内部会处理密码加密、关联表更新等逻辑
	 * 4. 返回更新操作的结果
	 * 
	 * @param user 包含更新信息的用户对象
	 * @param oldId 原用户ID，用于定位要更新的用户
	 * @return String 更新结果："SUCCESS"表示成功，"ERR"表示失败，"LGINOUT"表示需要重新登录
	 */
	@ResponseBody
	@RequestMapping("/updateUser")
	public String updateUser(User user, String oldId) {
		return userService.updateUser(oldId, user);
	}

	/**
	 * 跳转到已删除用户列表页面
	 * 
	 * 功能说明：
	 * - 显示系统中所有已删除的用户
	 * - 提供用户恢复功能
	 * - 用于用户数据管理和恢复
	 * 
	 * 实现逻辑：
	 * 1. 直接返回已删除用户列表页面的视图名称
	 * 2. 前端页面会通过AJAX调用getAllDelUserByLimit接口获取数据
	 * 
	 * @return String 返回已删除用户列表页面的视图名称 "sa/userDelPage"
	 */
	@RequestMapping("/delUserPage")
	public String delUserPage() {
		return "sa/userDelPage";
	}

	/**
	 * 恢复已删除的用户
	 * 
	 * 功能说明：
	 * - 批量恢复已删除的用户账号
	 * - 将用户状态从删除状态改为在职状态
	 * - 支持批量操作，提高管理效率
	 * 
	 * 实现逻辑：
	 * 1. 接收要恢复的用户ID数组
	 * 2. 遍历ID数组，逐个调用userService.recoverUser()方法
	 * 3. 将用户状态从USER_DELETE改为USER_ZAIZHI
	 * 4. 返回批量操作的结果
	 * 
	 * @param ids 要恢复的用户ID数组
	 * @return String 操作结果："SUCCESS"表示成功，"ERROR"表示失败
	 */
	@RequestMapping("/recoverUser")
	@ResponseBody
	public String recoverUser(String[] ids) {
		try {
			// 遍历用户ID数组，逐个恢复用户
			for (String id : ids) {
				userService.recoverUser(id);
			}
			return "SUCCESS";
		} catch (Exception e) {
			// 记录异常日志并返回错误信息
			logger.error("恢复用户异常", e);
			return "ERROR";
		}
	}
	
	
	//班级管理
	
	/**
	 * Method name: classesPage <BR>
	 * Description: 班级管理页面 <BR>
	 * 
	 * @return String<BR>
	 */
	@RequestMapping(value = "/classesPage")
	public String classesPage() {
		return "sa/Classes";
	}
	
	/**
	 * Method name: getAllClassByLimit <BR>
	 * Description: 根据条件获取所有班级 <BR>
	 * 
	 * @param classParameter
	 * @return Object<BR>
	 */
	@RequestMapping("/getAllClassByLimit")
	@ResponseBody
	public Object getAllClassByLimit(Classes classParameter) {
		return classService.getAllClassByLimit(classParameter);
	}
	
	/**
	 * Method name: addClassesPage <BR>
	 * Description: 增加班级界面 <BR>
	 * 
	 * @return String<BR>
	 */
	@RequestMapping(value = "/addClassesPage")
	public String addClassesPage(Integer id, Model model) {
		model.addAttribute("manageClasses", id);
		if (null != id) {
			Classes classes = classService.selectByPrimaryKey(id);
			model.addAttribute("manageClasses", classes);
		}
		List<User> user = userService.selectAllTea();
		model.addAttribute("user", user);
		return "sa/classesAdd";
	}
	
	/**
	 * Method name: addClasses <BR>
	 * Description: 班级添加 <BR>
	 * 
	 * @param classes
	 * @return String<BR>
	 */
	@ResponseBody
	@RequestMapping("/addClasses")
	public String addClasses(Classes classes) {
		try {
			classes.setCreateTime(new Date());
			classService.addClasses(classes);
			return "SUCCESS";
		} catch (Exception e) {
			return "ERR";
		}
	}

	/**
	 * Method name: updateClasses <BR>
	 * Description: 更新班级 <BR>
	 * 
	 * @param classes
	 * @return String<BR>
	 */
	@ResponseBody
	@RequestMapping("/updateClasses")
	public String updateClasses(Classes classes) {
		return classService.updateClasses(classes);
	}
	
	/**
	 * Method name: delClasses <BR>
	 * Description: 批量删除班级 <BR>
	 * 
	 * @param ids
	 * @return String<BR>
	 */
	@RequestMapping(value = "delClasses")
	@ResponseBody
	@Transactional
	public String delClasses(String[] ids) {
		try {
			for (String id : ids) {
				classService.delClassesById(Integer.parseInt(id));
			}
			return "SUCCESS";
		} catch (Exception e) {
			logger.error("根据班级id删除异常", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return "ERROR";
		}
	}
	
	

	//教师管理
	
	/**
	 * Method name: teacherPage <BR>
	 * Description: 教师管理页面 <BR>
	 * 
	 * @return String<BR>
	 */
	@RequestMapping(value = "/teaMG")
	public String teaMG() {
		return "sa/claTea";
	}
	
	/**
	 * Method name: getAllTeacherByLimit <BR>
	 * Description: 根据条件获取所有教师 <BR>
	 * 
	 * @param teaParameter
	 * @return Object<BR>
	 */
	@RequestMapping("/getAllTeacherByLimit")
	@ResponseBody
	public Object getAllTeacherByLimit(ClaTea teaParameter) {
		return teaService.getAllTeaByLimit(teaParameter);
	}
	
	/**
	 * Method name: addTeaPage <BR>
	 * Description: 增加教师界面 <BR>
	 * 
	 * @return String<BR>
	 */
	@RequestMapping(value = "/addTeaPage")
	public String addTeaPage(Integer id, Model model) {
		model.addAttribute("manageTea", id);
		if (null != id) {
			ClaTea clatea = teaService.selectByPrimaryKey(id);
			model.addAttribute("manageTea", clatea);
		}
		List<Classes> classes=classService.selectAllClasses();
		model.addAttribute("cla", classes);
		List<User> teacher=userService.selectAllTea();
		model.addAttribute("tea", teacher);
		return "sa/claTeaAdd";
	}
	
	/**
	 * Method name: addTea <BR>
	 * Description: 教师添加 <BR>
	 * 
	 * @param clatea
	 * @return String<BR>
	 */
	@ResponseBody
	@RequestMapping("/addTea")
	public String addTea(ClaTea clatea) {
		try {
			teaService.addClaTea(clatea);
			return "SUCCESS";
		} catch (Exception e) {
			return "ERR";
		}
	}

	/**
	 * Method name: updateClaTea <BR>
	 * Description: 更新教师 <BR>
	 * 
	 * @param clatea
	 * @return String<BR>
	 */
	@ResponseBody
	@RequestMapping("/updateClaTea")
	public String updateClaTea(ClaTea clatea) {
		return teaService.updateTea(clatea);
	}
	
	/**
	 * Method name: delClaTea <BR>
	 * Description: 批量删除教师<BR>
	 * 
	 * @param ids
	 * @return String<BR>
	 */
	@RequestMapping(value = "delClaTea")
	@ResponseBody
	@Transactional
	public String delClaTea(String[] ids) {
		try {
			for (String id : ids) {
				teaService.delClaTeaById(Integer.parseInt(id));
			}
			return "SUCCESS";
		} catch (Exception e) {
			logger.error("根据班级id删除异常", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return "ERROR";
		}
	}

	//工资管理
	
		/**
		 * Method name: payMG <BR>
		 * Description: 工资管理页面 <BR>
		 * 
		 * @return String<BR>
		 */
		@RequestMapping(value = "/payMG")
		public String payMG() {
			return "sa/pay";
		}
		
		/**
		 * Method name: getAllPayByLimit <BR>
		 * Description: 根据条件获取所有工资 <BR>
		 * 
		 * @param payParameter
		 * @return Object<BR>
		 */
		@RequestMapping("/getAllPayByLimit")
		@ResponseBody
		public Object getAllPayByLimit(Pay payParameter) {
			return payService.getAllPayByLimit(payParameter);
		}
		
		/**
		 * Method name: addTeaPage <BR>
		 * Description: 增加工资界面 <BR>
		 * 
		 * @return String<BR>
		 */
		@RequestMapping(value = "/addPayPage")
		public String addPayPage(Integer id, Model model) {
			model.addAttribute("managePay", id);
			if (null != id) {
				Pay pay = payService.selectByPrimaryKey(id);
				model.addAttribute("managePay", pay);
			}
			//向前端传参到下拉列表
			List<User> teacher=userService.selectAllTea();
			model.addAttribute("tea", teacher);
			return "sa/payAdd";
		}
		
		/**
		 * Method name: addPay <BR>
		 * Description: 添加工资 <BR>
		 * 
		 * @param pay
		 * @return String<BR>
		 */
		@ResponseBody
		@RequestMapping("/addPay")
		public String addPay(Pay pay) {
			try {
				pay.setPaymentTime(new Date());
				payService.addPayTea(pay);
				return "SUCCESS";
			} catch (Exception e) {
				return "ERR";
			}
		}

		/**
		 * Method name: updatePay <BR>
		 * Description: 更新工资 <BR>
		 * 
		 * @param pay
		 * @return String<BR>
		 */
		@ResponseBody
		@RequestMapping("/updatePay")
		public String updatePay(Pay pay) {
			return payService.updateTea(pay);
		}
		
		/**
		 * Method name: delPay <BR>
		 * Description: 批量删除工资<BR>
		 * 
		 * @param ids
		 * @return String<BR>
		 */
		@RequestMapping(value = "delPay")
		@ResponseBody
		@Transactional
		public String delPay(String[] ids) {
			try {
				for (String id : ids) {
					payService.delClaTeaById(Integer.parseInt(id));
				}
				return "SUCCESS";
			} catch (Exception e) {
				logger.error("根据班级id删除异常", e);
				TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
				return "ERROR";
			}
		}
		
		//物资管理
		
			/**
			 * Method name: materialMG <BR>
			 * Description: 物资管理页面 <BR>
			 * 
			 * @return String<BR>
			 */
			@RequestMapping(value = "/materialMG")
			public String materialMG() {
				return "sa/material";
			}
			
			/**
			 * Method name: getAllMaterialByLimit <BR>
			 * Description: 根据条件获取所有物资 <BR>
			 * 
			 * @param materialParameter
			 * @return Object<BR>
			 */
			@RequestMapping("/getAllMaterialByLimit")
			@ResponseBody
			public Object getAllMaterialByLimit(Material materialParameter) {
				return materialService.getAllMaterialByLimit(materialParameter);
			}
			
			/**
			 * Method name: addMaterialPage <BR>
			 * Description: 增加物资界面 <BR>
			 * 
			 * @return String<BR>
			 */
			@RequestMapping(value = "/addMaterialPage")
			public String addMaterialPage(Integer id, Model model) {
				model.addAttribute("manageMaterial", id);
				if (null != id) {
					Material material = materialService.selectByPrimaryKey(id);
					model.addAttribute("manageMaterial", material);
				}
				
				return "sa/materialAdd";
			}
			
			/**
			 * Method name: addMaterial <BR>
			 * Description: 物资添加 <BR>
			 * 
			 * @param material
			 * @return String<BR>
			 */
			@ResponseBody
			@RequestMapping("/addMaterial")
			public String addMaterial(Material material) {
				try {
					material.setCreateTime(new Date());
					materialService.addMaterial(material);
					return "SUCCESS";
				} catch (Exception e) {
					return "ERR";
				}
			}

			/**
			 * Method name: updateMaterial <BR>
			 * Description: 更新物资 <BR>
			 * 
			 * @param material
			 * @return String<BR>
			 */
			@ResponseBody
			@RequestMapping("/updateMaterial")
			public String updateMaterial(Material material) {
				return materialService.updateMaterial(material);
			}
			
			/**
			 * Method name: delClaTea <BR>
			 * Description: 批量删除物资<BR>
			 * 
			 * @param ids
			 * @return String<BR>
			 */
			@RequestMapping(value = "delMaterial")
			@ResponseBody
			@Transactional
			public String delMaterial(String[] ids) {
				try {
					for (String id : ids) {
						materialService.delMaterialById(Integer.parseInt(id));
					}
					return "SUCCESS";
				} catch (Exception e) {
					logger.error("根据班级id删除异常", e);
					TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
					return "ERROR";
				}
			}
			
			//菜单管理
			
			/**
			 * Method name: foodMG <BR>
			 * Description: 菜单管理页面 <BR>
			 * 
			 * @return String<BR>
			 */
			@RequestMapping(value = "/footMG")
			public String foodMG() {
				return "sa/food";
			}
			
			/**
			 * Method name: getAllFoodByLimit <BR>
			 * Description: 根据条件获取所有菜单 <BR>
			 * 
			 * @param food
			 * @return Object<BR>
			 */
			@RequestMapping("/getAllFoodByLimit")
			@ResponseBody
			public Object getAllFoodByLimit(Food food) {
				return foodService.getAllFoodByLimit(food);
			}
			
			/**
			 * Method name: addFoodPage <BR>
			 * Description: 增加菜单界面 <BR>
			 * 
			 * @return String<BR>
			 */
			@RequestMapping(value = "/addFoodPage")
			public String addFoodPage(Integer id, Model model) {
				model.addAttribute("manageFood", id);
				if (null != id) {
					Food food = foodService.selectByPrimaryKey(id);
					model.addAttribute("manageFood", food);
				}
				
				return "sa/foodAdd";
			}
			
			/**
			 * Method name: addFood <BR>
			 * Description: 菜单添加 <BR>
			 * 
			 * @param food
			 * @return String<BR>
			 */
			@ResponseBody
			@RequestMapping("/addFood")
			public String addFood(Food food) {
				try {
					food.setCreateTime(new Date());
					foodService.addFood(food);
					return "SUCCESS";
				} catch (Exception e) {
					return "ERR";
				}
			}

			/**
			 * Method name: updateFood <BR>
			 * Description: 更新菜单 <BR>
			 * 
			 * @param food
			 * @return String<BR>
			 */
			@ResponseBody
			@RequestMapping("/updateFood")
			public String updateFood(Food food) {
				return foodService.updateFood(food);
			}
			
			/**
			 * Method name: delFood <BR>
			 * Description: 批量删除菜单<BR>
			 * 
			 * @param ids
			 * @return String<BR>
			 */
			@RequestMapping(value = "delFood")
			@ResponseBody
			@Transactional
			public String delFood(String[] ids) {
				try {
					for (String id : ids) {
						foodService.delFoodById(Integer.parseInt(id));
					}
					return "SUCCESS";
				} catch (Exception e) {
					logger.error("根据班级id删除异常", e);
					TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
					return "ERROR";
				}
			}
}
